home *** CD-ROM | disk | FTP | other *** search
/ Amiga News 96 / Amiga News 96.iso / amig_ad_os / laurent_faillie / lfcinter / lfci_lex.cxx < prev    next >
C/C++ Source or Header  |  1977-12-31  |  7KB  |  189 lines
  1. /***************************************************************************\
  2. *  LFCI_Lex.cxx                                                             *
  3. *  Projet : LFCInter                                                        *
  4. *      © LFSoft 1995-96                                                     *
  5. *                                                                           *
  6. *  Analyse lexicale.                                                        *
  7. *                                                                           *
  8. *   Note: Dans ce fichier il y a des caratères '(',')','{','}'... mis en    *
  9. *   commentaire. C'est uniquement pour permettre à mon éditeur de tester    *
  10. *   les blocs...                                                            *
  11. *                                                                           *
  12. \*************** Voir LFCInter pour plus d'informations ********************/
  13.  
  14. #include "LFCInter.h"
  15. #include "LFDStack.h"
  16. #include "Token.h"
  17. #include "LFCI_Cal.h"
  18.  
  19. static void *alloue(string &type,LFDynaStack<unsigned int> &taille,int idx,_resallouee **mem,_token &ptr){
  20. /*  Allocation d'une dimension d'un tableau.
  21.  *  Cette fonction est appellée récursivement pour allouer chaque dimension du tableau
  22.  *
  23.  *  type: type d'objet à allouer
  24.  *  taille: pile des dimension du tableau
  25.  *  idx: index de la dimension à allouer dans la pile
  26.  *  mem: pointeur sur un pointeur sur le premier élément de la liste des ressources allouées pour ce tableau
  27.  */
  28.  
  29.     if( idx<taille.length() ){ // Ce n'est pas la derniere dimension que l'on alloue
  30.         int i;
  31.         void **x=(void **)calloc(sizeof(void*),taille[idx]);
  32.  
  33.         if(!x){
  34.             cerr << "*E* Ligne " << calcligne(ptr) << ": Manque de mémoire.\n";
  35.             exit(5);
  36.         }
  37.  
  38.         for(i=0; i<taille[idx]; i++)
  39.             x[i]=alloue(type,taille,idx+1,mem,ptr);
  40.  
  41.         *mem= new _resallouee(*mem,(void *)x);
  42.         if(!*mem){
  43.             cerr << "*E* Ligne " << calcligne(ptr) << ": Manque de mémoire.\n";
  44.             exit(5);
  45.         }
  46.  
  47.         return (void *)x;
  48.     } else {
  49.         size_t t;
  50.         switch(type[0]){
  51.         case 'C':
  52.             t=sizeof(char); break;
  53.         case 'I':
  54.             t=sizeof(int); break;
  55.         case '*':
  56.             t=sizeof(void *); break;
  57.         default:
  58.             cerr << "*E* Ligne " << calcligne(ptr) << ": Impossible de déterminer la taille d'un objet de type '" << type[0] << "'.\n";
  59.             exit(5);
  60.         };
  61.  
  62.         void *x = calloc(t,taille[idx]);
  63.         if(!x){
  64.             cerr << "*E* Ligne " << calcligne(ptr) << ": Manque de mémoire.\n";
  65.             exit(5);
  66.         }
  67.  
  68.         *mem= new _resallouee(*mem,x);
  69.         if(!*mem){
  70.             cerr << "*E* Ligne " << calcligne(ptr) << ": Manque de mémoire.\n";
  71.             exit(5);
  72.         }
  73.  
  74.         return x;
  75.     }
  76. }
  77.  
  78. bool lecdesc( _token &ptr, string &id, string &type, char itype, void **mem,_tablesmb *table_locale){
  79. /* Lecture d'une définition.
  80.  *  <-  ptr: Début de la chaîne à évaluer.
  81.  *      itype: Type initial.
  82.  *      mem : NULL si on ne veut que lire les descripteurs (pas d'allocation de mémoire)
  83.  *
  84.  *  -> false si le premier symbole n'est pas un type.
  85.  *      ptr : pointe sur le premier objet qui suit la définition (pas besoin de ++)
  86.  *      id : Identificateur.
  87.  *      mem :
  88.  *          .Si le type 'imédiat' est un tableau (T), cette variable pointe
  89.  *      vers les resources qui lui sont allouées (class _resallouee).
  90.  *          .En cas de définition de fonction, cette variable pointe sur sur le
  91.  *      '(' de définition des arguments. // )
  92.  */
  93.     _token porg = ptr;
  94.     type = "";
  95.     id = "";
  96.     if(mem) *mem= NULL;
  97.  
  98.     if(itype){ // Le type initial est donné
  99.         type = itype;
  100.         if(!ptr.definition()) // Il n'y a que le nom de la variable
  101.             goto lex_id;
  102.     } else if( !ptr.definition() || *ptr=='*' ){ // Ce n'est pas une définition
  103. /* Si le premier caractère est un '*' ce n'est pas une définition mais un
  104.  * déréférencement...
  105.  */
  106.         ptr = porg;
  107.         return false;
  108.     }
  109.  
  110.     do {
  111.         switch(*ptr){
  112.         case -2: // Qualificateur ignoré
  113.             break;
  114.         case smbl_void:
  115.             if(type.length()){
  116.                 cerr << "*E* Ligne " << calcligne(ptr) << ": Erreur de syntaxe lors d'une déclaration." << ADEB("(lex:1)" << ) "\n";
  117.                 exit(5);
  118.             }
  119.             type = 'V';
  120.             break;
  121.         case smbl_int:
  122.             if(type.length()){
  123.                 cerr << "*E* Ligne " << calcligne(ptr) << ": Erreur de syntaxe lors d'une déclaration." << ADEB("(lex:2)" << ) "\n";
  124.                 exit(5);
  125.             }
  126.             type = 'I';
  127.             break;
  128.         case smbl_char:
  129.             if(type.length()){
  130.                 cerr << "*E* Ligne " << calcligne(ptr) << ": Erreur de syntaxe lors d'une déclaration." << ADEB("(lex:3)" << ) "\n";
  131.                 exit(5);
  132.             }
  133.             type = 'C';
  134.             break;
  135.         case '*':
  136.                 // Si aucun type n'a été défini, c'est un pointeur sur un entier
  137.             if(!type.length()) type='I';
  138.             type= '*' + type;
  139.             break;
  140.         default:
  141.             cerr << "*E* Ligne " << calcligne(ptr) << ": Erreur de syntaxe lors d'une déclaration." << ADEB("(lex:4)" << ) "\n";
  142.             exit(5);
  143.         }
  144.         ptr++;
  145.     } while( ptr.definition() ); // On reste dans la boucle tant que ce qu'on lit est un type
  146.  
  147. lex_id:
  148.     id = ptr.obj();
  149.  
  150.     if(*ptr != smbl_id){
  151.         cerr << "*E* Ligne " << calcligne(ptr) << ": Un identificateur était attendu.\n";
  152.         exit(5);
  153.     }
  154.  
  155.     ptr++;
  156.     if(*ptr == '[' /* ] */ ){   // Définition d'un tableau
  157.         LFDynaStack<unsigned int> taille(5); // Stockage des différentes dimensions du tableau
  158.  
  159.         if(!mem){
  160.             cerr << "*F* Ligne " << calcligne(ptr) << ": Tentative pour allouer un tableau où une allocation était interdite.\n";
  161.             exit(5);
  162.         }
  163.  
  164.         do {
  165.             ptr++;
  166.             taille.Push( (unsigned int)conv('I',eval(ptr,table_locale),ptr).val.entier );
  167.             if(*ptr != /*[*/ ']'){
  168.                 cerr << "*E* Ligne " << calcligne(ptr) << /*[*/ ": Erreur de syntaxe, il manque le ']' de fermeture d'une déclaration de tableau.\n";
  169.                 exit(5);
  170.             }
  171.         } while(*++ptr == '[' /*]*/ );
  172.  
  173.         alloue(type,taille,0,(_resallouee **)mem,ptr);
  174.  
  175.             // Seul le type de base est un tableau, les autres sont de 'simples' pointeurs
  176.         for(int i=0; i<taille.length(); i++)
  177.             type = '*' + type;
  178.  
  179.         type = 'T' + type;
  180.  
  181.     } else if(*ptr == '(' /* ) */){ // Définition d'une fonction
  182.         if(mem) *mem = (void *) ((const char *)ptr + 1);
  183.         ptr.saute();
  184.         type = 'F' + type;
  185.     }
  186.  
  187.     return true;
  188. }
  189.